/* 
文件名称: data_import.js
完整存储路径: frontend/static/js/data_import.js
功能说明:
    该文件处理数据导入页面的所有交互，包括选择文件、拖拽文件、显示文件列表、上传文件、显示上传状态和处理文件删除等。
使用方法:
    加载页面时，页面元素会自动绑定相关的事件，包括文件选择、文件上传等交互功能。
*/
document.addEventListener('DOMContentLoaded', () => {
  const fileInput = document.getElementById('fileInput');
  const selectFileBtn = document.getElementById('selectFileBtn');
  const cancelBtn = document.getElementById('cancelBtn');
  const uploadBtn = document.getElementById('uploadBtn');
  const fileList = document.getElementById('fileList');
  const uploadArea = document.getElementById('uploadArea');
  const uploadStatus = document.getElementById('uploadStatus');
  const dataYearSelect = document.getElementById('dataYearSelect');

  // 存储选择的文件（数组）
  let selectedFiles = [];

  // 更新显示选中文件列表
  function updateFileList() {
    if (selectedFiles.length === 0) {
      fileList.innerHTML = '<p class="text-muted">暂无选中文件</p>';
      return;
    }
    fileList.innerHTML = '';
    selectedFiles.forEach((file, index) => {
      const fileItem = document.createElement('div');
      fileItem.style.display = 'flex';
      fileItem.style.justifyContent = 'space-between';
      fileItem.style.alignItems = 'center';
      fileItem.style.padding = '6px 0';
      fileItem.style.borderBottom = '1px solid #eee';
      fileItem.innerHTML = `
        <span>${file.name}</span>
        <button type="button" class="btn btn-sm btn-link text-danger" data-index="${index}">
          <i class="bi bi-x-circle"></i>
        </button>`;
      fileList.appendChild(fileItem);
    });
  }

  // 选择文件按钮点击
  selectFileBtn.addEventListener('click', () => {
    fileInput.click();  // 触发文件选择框
  });

  // 文件输入改变时更新文件列表
  fileInput.addEventListener('change', (e) => {
    const files = Array.from(e.target.files);
    selectedFiles = selectedFiles.concat(files);
    updateFileList();
  });

  // 处理拖拽文件
  uploadArea.addEventListener('dragover', (e) => {
    e.preventDefault();
    uploadArea.style.backgroundColor = '#f7f7f7';
  });

  uploadArea.addEventListener('dragleave', (e) => {
    e.preventDefault();
    uploadArea.style.backgroundColor = '';
  });

  uploadArea.addEventListener('drop', (e) => {
    e.preventDefault();
    uploadArea.style.backgroundColor = '';
    const files = Array.from(e.dataTransfer.files).filter(file => {
      const ext = file.name.split('.').pop().toLowerCase();
      return ext === 'xlsx' || ext === 'csv';
    });
    selectedFiles = selectedFiles.concat(files);
    updateFileList();
  });

  // 点击取消上传按钮，清空选中文件
  cancelBtn.addEventListener('click', () => {
    selectedFiles = [];
    fileInput.value = '';
    updateFileList();
    uploadStatus.innerHTML = '<div class="alert alert-info mt-2">已取消所有选择的文件。</div>';
  });

  // 绑定删除单个文件事件（通过委托方式绑定）
  fileList.addEventListener('click', (e) => {
    if (e.target.closest('button')) {
      const index = e.target.closest('button').getAttribute('data-index');
      selectedFiles.splice(index, 1);
      updateFileList();
    }
  });

  // 上传文件按钮点击
  uploadBtn.addEventListener('click', () => {
    if (selectedFiles.length === 0) {
      uploadStatus.innerHTML = '<div class="alert alert-warning mt-2">请选择要上传的文件。</div>';
      return;
    }
    
    // 验证数据年份选择
    const dataYear = dataYearSelect.value;
    if (!dataYear) {
      uploadStatus.innerHTML = '<div class="alert alert-warning mt-2">请选择数据年份。</div>';
      return;
    }
    
    // 记录原始文件名，用于错误处理时显示
    const originalFileName = selectedFiles[0].name;
    
    const formData = new FormData();
    formData.append('data_year', dataYear);
    selectedFiles.forEach(file => {
      formData.append('file', file);
    });
    
    // 显示上传状态
    uploadStatus.innerHTML = '<div class="alert alert-info mt-2">正在上传，请稍候……</div>';
    
    fetch("/api/students/import", {
      method: 'POST',
      body: formData
    })
      .then(response => response.json())
      .then(result => {
        console.log('完整服务器响应:', result);
        
        // 确保错误响应也包含文件名信息
        if (!result.original_filename && !result.filename) {
          result.original_filename = originalFileName;
        }
        if (!result.data_year) {
          result.data_year = dataYear;
        }
        
        // 先清空上传状态
        uploadStatus.innerHTML = '';
        
        // 调用统一的响应处理函数
        handleImportResponse(result);
      })
      .catch(err => {
        console.error('上传错误:', err);
        // 网络错误时也显示文件名
        handleImportResponse({
          error: '网络错误或服务器异常',
          original_filename: originalFileName,
          data_year: dataYear
        });
      });
  });

  // 统一的响应处理函数 - 修复重复定义问题
  function handleImportResponse(response) {
    console.log('处理导入响应:', response);
    
    // 清空上传状态显示
    uploadStatus.innerHTML = '';
    
    // 确保获取文件名 - 从多个可能的字段中获取
    const fileName = response.original_filename || response.filename || '未知文件';
    const dataYear = response.data_year || '未知年份';
    
    // 检查响应格式 - 根据实际返回的数据结构判断成功还是失败
    if (response.total_rows !== undefined) {
        // 有total_rows字段说明导入已执行，不管成功失败都显示结果
        console.log('检测到total_rows字段，作为成功响应处理');
        showImportResult(response, fileName, dataYear, true);
    } else {
        // 没有total_rows说明导入过程出错
        console.log('没有total_rows字段，作为错误响应处理');
        showImportResult(response, fileName, dataYear, false);
    }
  }

  // 统一的结果显示函数 - 修复重复导入统计显示
  function showImportResult(result, fileName, dataYear, isSuccess) {
    const importSummary = document.getElementById('import-summary');
    const importResult = document.getElementById('import-result');
    
    if (isSuccess) {
      console.log('处理成功响应:', result);
      
      // 构建成功导入结果摘要 - 增强重复导入显示
      let summary = `文件 "${fileName}" (${dataYear}年数据) 导入完成：`;
      
      if (result.success_count > 0) {
        summary += `新增 ${result.success_count} 条`;
      }
      
      if (result.update_count > 0) {
        if (result.success_count > 0) summary += `，`;
        summary += `更新 ${result.update_count} 条`;
      }
      
      if (result.duplicate_no_change > 0) {
        if (result.success_count > 0 || result.update_count > 0) summary += `，`;
        summary += `重复无变化 ${result.duplicate_no_change} 条`;
      }
      
      if (result.error_count && result.error_count > 0) {
        summary += `，错误 ${result.error_count} 条`;
      }
      
      summary += `，成功率 ${result.success_rate || 0}%`;
      
      // 显示导入结果
      if (importSummary && importResult) {
        let resultHtml = `
          <div class="alert alert-success">
            <h5><i class="fas fa-check-circle"></i> 导入完成</h5>
            <p><strong>文件名：</strong>${fileName}</p>
            <p><strong>数据年份：</strong>${dataYear}</p>
            <p><strong>导入结果：</strong>${result.message || summary}</p>
            <div class="mt-3">
              <strong>详细统计：</strong>
              <ul class="mb-0">
                <li>总行数：${result.total_rows || 0}</li>
                <li>成功导入：${result.success_count || 0} 条</li>
        `;
        
        // 增强：显示更新记录详情
        if (result.update_count > 0) {
          resultHtml += `<li class="text-info">更新记录：${result.update_count} 条（有字段更新）</li>`;
        }
        
        if (result.duplicate_no_change > 0) {
          resultHtml += `<li class="text-muted">重复记录：${result.duplicate_no_change} 条（无变化）</li>`;
        }
        
        resultHtml += `
                <li>错误记录：${result.error_count || 0} 条</li>
                <li>总重复记录：${result.duplicate_education_ids || 0} 条</li>
                <li>成功率：${result.success_rate || 0}%</li>
              </ul>
            </div>
        `;
        
        // 修复：错误记录下载按钮逻辑 - 确保不重复添加
        if (result.error_count && result.error_count > 0) {
          resultHtml += `
            <div class="mt-3 p-3 bg-light border rounded">
              <h6><i class="fas fa-exclamation-triangle text-warning"></i> 错误记录处理</h6>
              <p class="mb-2 text-muted">发现 ${result.error_count} 条错误记录</p>
          `;
          
          // 检查下载URL - 修复：检查多个可能的字段
          console.log('检查下载URL字段:', {
            error_log_download_url: result.error_log_download_url,
            error_file_path: result.error_file_path,
            error_log_filename: result.error_log_filename
          });
          
          const downloadUrl = result.error_log_download_url || result.error_file_path;
          
          if (downloadUrl) {
            // 修复：使用唯一ID，避免重复绑定
            const buttonId = `download-error-btn-${Date.now()}`;
            resultHtml += `
              <button type="button" id="${buttonId}" class="btn btn-outline-danger btn-sm" 
                      data-download-url="${downloadUrl}">
                <i class="fas fa-download me-1"></i>下载完整错误记录
              </button>
              <small class="text-muted ms-2">CSV格式，包含解决方案建议</small>
            `;
            console.log('✅ 错误下载按钮已添加，URL:', downloadUrl);
          } else {
            resultHtml += `
              <div class="alert alert-warning mb-0">
                <i class="fas fa-info-circle"></i> 错误记录文件生成中，请稍后刷新页面或联系管理员
              </div>
            `;
          }
          
          resultHtml += '</div>';
        }
        
        resultHtml += '</div>';
        importSummary.innerHTML = resultHtml;
        
        // 修复：事件委托，避免重复绑定
        importSummary.removeEventListener('click', handleDownloadClick);
        importSummary.addEventListener('click', handleDownloadClick);
        
        importResult.style.display = 'block';
      }
      
    } else {
      console.log('处理错误响应:', result);
      
      // 显示错误结果
      const errorMessage = result.error || '导入失败';
      const errorDetails = result.details || '';
      
      if (importSummary && importResult) {
        importSummary.innerHTML = `
          <div class="alert alert-danger">
            <h5><i class="fas fa-exclamation-circle"></i> 导入失败</h5>
            <p><strong>文件名：</strong>${fileName}</p>
            ${dataYear !== '未知年份' ? `<p><strong>数据年份：</strong>${dataYear}</p>` : ''}
            <p><strong>错误信息：</strong>${errorMessage}</p>
            ${errorDetails ? `<p><strong>详细说明：</strong>${errorDetails}</p>` : ''}
            ${result.validation_type === 'year_mismatch' ? `
              <div class="mt-2 p-2 bg-light rounded">
                <small class="text-muted">
                  <i class="fas fa-info-circle"></i> 
                  请确保文件名包含对应的年份信息，或检查年份选择是否正确
                </small>
              </div>
            ` : ''}
          </div>
        `;
        importResult.style.display = 'block';
      }
    }
    
    // 清空文件选择
    selectedFiles = [];
    fileInput.value = '';
    updateFileList();
    
    // 滚动到结果区域
    if (importResult) {
      importResult.scrollIntoView({ behavior: 'smooth' });
    }
  }

  function showErrorSection(result) {
    const errorSection = document.getElementById('error-log-section');
    if (!errorSection) {
        console.error('找不到错误区域元素');
        return;
    }
    
    errorSection.style.display = 'block';
    console.log('错误区域已显示');
    
    // 设置下载按钮事件
    const downloadBtn = document.getElementById('download-error-log');
    if (downloadBtn) {
        // 移除旧的事件监听器
        downloadBtn.onclick = null;
        
        // 设置新的事件监听器
        downloadBtn.onclick = function(event) {
            event.preventDefault();
            console.log('点击下载按钮');
            
            // 检查是否有错误文件路径
            if (result.error_file_path) {
                console.log('使用错误文件路径下载:', result.error_file_path);
                downloadErrorFile(result.error_file_path);
            } else {
                console.error('错误文件路径不存在');
                alert('错误文件路径不存在，请联系管理员');
            }
        };
        console.log('下载按钮事件已绑定');
    } else {
        console.error('找不到下载按钮元素');
    }
    
    // 显示错误预览（如果有的话）
    if (result.error_preview && Array.isArray(result.error_preview) && result.error_preview.length > 0) {
        console.log('显示错误预览');
        const errorPreview = document.getElementById('error-preview');
        const errorContent = document.getElementById('error-content');
        if (errorPreview && errorContent) {
            errorPreview.style.display = 'block';
            errorContent.textContent = result.error_preview.join('\n');
            console.log('错误预览已显示');
        }
    } else {
        console.log('没有错误预览数据');
    }
  }

  // 修复：使用事件委托处理下载点击
  function handleDownloadClick(event) {
    if (event.target.closest('button[data-download-url]')) {
      const button = event.target.closest('button[data-download-url]');
      const downloadUrl = button.getAttribute('data-download-url');
      downloadErrorFile(downloadUrl);
    }
  }

  // 错误文件下载函数 - 保持原有逻辑
  function downloadErrorFile(downloadUrl) {
    console.log('开始下载错误文件:', downloadUrl);
    try {
      // 创建下载链接
      const link = document.createElement('a');
      link.href = downloadUrl;
      
      // 生成文件名
      const now = new Date();
      const timestamp = now.getFullYear() + 
                       String(now.getMonth() + 1).padStart(2, '0') + 
                       String(now.getDate()).padStart(2, '0') + '_' +
                       String(now.getHours()).padStart(2, '0') + 
                       String(now.getMinutes()).padStart(2, '0') + 
                       String(now.getSeconds()).padStart(2, '0');
      link.download = `导入错误记录_${timestamp}.csv`;
      
      // 执行下载
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
      
      console.log('下载链接已触发');
      
    } catch (error) {
      console.error('下载错误文件失败:', error);
      alert('下载失败，请重试');
    }
  }
});